#!/usr/bin/env python3
"""定时同步调度器 - 负责定时触发媒体库JSON数据的重新生成和缓存更新"""

import json
import yaml
import os
import asyncio
import logging
import sys
from datetime import datetime, timedelta
from typing import Dict, Any

# 添加项目根目录到Python路径
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from embytools.emby_client import EmbyClient
from embytools.douyin_exporter import export_emby_library_to_douyin_json
from dashboard.data_manager import get_data_manager

# 确保logs目录存在
logs_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'logs')
os.makedirs(logs_dir, exist_ok=True)

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(os.path.join(logs_dir, 'sync_scheduler.log')),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger('sync_scheduler')

# 配置文件路径
CONFIG_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'config', 'config.yaml')
JSON_OUTPUT_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'output')


def load_config() -> Dict[str, Any]:
    """加载配置文件"""
    if os.path.exists(CONFIG_PATH):
        with open(CONFIG_PATH, 'r', encoding='utf-8') as f:
            return yaml.safe_load(f) or {}
    return {}


def get_emby_config() -> Dict[str, Any]:
    """获取Emby配置"""
    # 尝试从配置文件获取，否则返回默认配置
    config = load_config()
    emby_config = config.get('emby', {})
    
    # 如果配置文件中没有Emby配置，则使用默认值
    if not emby_config:
        return {
            'host': '192.168.50.46',
            'port': 8096,
            'https': False,
            'token': '0ffa981958ed498aa646b5689641db6e',
            'name': 'main',
            'user_id': ''
        }
    return emby_config


async def regenerate_libraries_json() -> bool:
    """重新生成媒体库JSON数据并更新缓存"""
    try:
        logger.info("开始重新生成媒体库JSON数据并更新缓存...")
        
        # 使用数据管理器强制刷新媒体库数据（会自动更新缓存）
        data_manager = get_data_manager()
        libraries = await data_manager.get_libraries(force_refresh=True)
        
        logger.info(f"媒体库数据刷新完成，共 {len(libraries)} 个媒体库，缓存已更新")
        
        # 确保输出目录存在
        os.makedirs(JSON_OUTPUT_DIR, exist_ok=True)
        
        # 保存JSON数据
        output_file = os.path.join(JSON_OUTPUT_DIR, 'libraries.json')
        with open(output_file, 'w', encoding='utf-8') as f:
            json.dump({
                'success': True,
                'libraries': libraries,  # 使用正确的变量名
                'generated_at': datetime.now().isoformat()
            }, f, ensure_ascii=False, indent=2)
        
        logger.info(f"媒体库JSON数据重新生成成功，保存到: {output_file}")
        
        # 同时生成抖音数据源的JSON文件
        await generate_douyin_json_for_enabled_sources()
        
        return True
        
    except Exception as e:
        logger.error(f"重新生成媒体库JSON数据失败: {e}")
        return False

async def generate_douyin_json_for_enabled_sources():
    """为所有启用的抖音数据源生成JSON文件"""
    try:
        logger.info("开始为启用的抖音数据源生成JSON文件...")
        
        # 获取数据管理器和配置
        data_manager = get_data_manager()
        douyin_sources = data_manager.get_douyin_sources()
        config = data_manager.load_config()
        emby_config = config.get('server', {})
        
        # 构建Emby服务器URL和API密钥
        emby_server = f"{'https' if emby_config.get('https', False) else 'http'}://{emby_config.get('host', 'localhost')}:{emby_config.get('port', 8096)}"
        api_key = emby_config.get('token', '')
        
        # 获取所有启用的数据源
        sources = douyin_sources.get('sources', [])
        enabled_sources = [s for s in sources if s.get('enabled', False) and s.get('library_id')]
        
        if not enabled_sources:
            logger.info("没有启用的抖音数据源，跳过JSON生成")
            return
        
        logger.info(f"找到 {len(enabled_sources)} 个启用的抖音数据源")
        
        # 为每个启用的数据源生成JSON
        for source in enabled_sources:
            try:
                logger.info(f"生成数据源 {source.get('name')} 的JSON文件...")
                
                # 调用导出函数，传递only_portrait参数
                result = await export_emby_library_to_douyin_json(
                    library_id=source['library_id'],
                    library_name=source.get('library_name', 'Emby媒体库'),
                    emby_server=emby_server,
                    api_key=api_key,
                    only_portrait_videos=source.get('only_portrait', False)
                )
                
                logger.info(f"数据源 {source.get('name')} 的JSON文件生成成功")
            except Exception as e:
                logger.error(f"生成数据源 {source.get('name')} 的JSON文件失败: {e}")
        
        logger.info("所有抖音数据源JSON文件生成完成")
    except Exception as e:
        logger.error(f"为抖音数据源生成JSON文件时发生错误: {e}")


async def scheduler():
    """定时任务调度器"""
    logger.info("定时同步调度器启动")
    
    last_sync_time = None
    data_manager = get_data_manager()
    
    while True:
        try:
            # 使用数据管理器加载配置
            config = data_manager.load_config()
            sync_config = config.get('douyin_sources', {}).get('sync', {})
            
            # 检查是否启用了同步
            if sync_config.get('enabled', False):
                interval_hours = sync_config.get('interval_hours', 24)
                
                # 检查是否需要执行同步
                now = datetime.now()
                if last_sync_time is None or now - last_sync_time >= timedelta(hours=interval_hours):
                    logger.info(f"执行定时同步任务，间隔: {interval_hours}小时")
                    await regenerate_libraries_json()
                    last_sync_time = now
            else:
                # 如果未启用同步，重置最后同步时间
                last_sync_time = None
                logger.debug("同步未启用，等待配置变更...")
            
            # 每分钟检查一次配置
            await asyncio.sleep(60)
            
        except Exception as e:
            logger.error(f"调度器错误: {e}")
            # 出错后等待10秒再继续
            await asyncio.sleep(10)


async def main():
    """主函数"""
    try:
        # 启动调度器
        await scheduler()
        
    except KeyboardInterrupt:
        logger.info("定时同步调度器被用户中断")
    except Exception as e:
        logger.error(f"定时同步调度器异常退出: {e}")


if __name__ == "__main__":
    asyncio.run(main())